home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1997 February / macformat-047.iso / Shareware Plus / Developers / DLOGManager 1.02 / Source Code / StrUtilities.cp < prev    next >
Encoding:
Text File  |  1996-09-16  |  6.2 KB  |  379 lines  |  [TEXT/KAHL]
  1. /*****
  2.  *    StrUtilities.c
  3.  *
  4.  *    Routines di utilità per stringhe.
  5.  *    © Com&Media, 1994
  6.  *
  7.  *    16/10/94    Scorporo da Utilities.c (Fabio Barbieri)
  8.  *    18/8/94        Prima stesura (Fabio Barbieri)
  9.  *
  10.  *
  11.  *****/
  12.  
  13.  
  14. /*****    Include standard        *****/
  15. #include <stdio.h>
  16. #include <string.h>
  17. #include <Script.h>
  18. #include <TextUtils.h>
  19.  
  20. /*****    Include locali            *****/
  21. #include "StrUtilities.h"
  22.  
  23. /*****    Define macro            *****/
  24.  
  25. /*****    Define valori            *****/
  26.  
  27. #pragma segment StrUtilities
  28.  
  29. /*****    Typedef globali            *****/
  30.  
  31. /*****    Funzioni esterne        *****/
  32.  
  33. /*****    Variabili esterne        *****/
  34.  
  35. /*****    Variabili globali        *****/
  36.  
  37. /*****    Statiche globali        *****/
  38.  
  39. /*****    Function prototyping    *****/
  40.  
  41.  
  42. /****
  43.  *    ConcatString(str1,str2)
  44.  *
  45.  *    Concatena la stringa <str2> alla stringa <str1>.
  46.  *
  47.  ****/
  48.  
  49. void ConcatString(Str255 str1,Str255 str2)
  50. {
  51.     register short    i;
  52.  
  53.     for(i = str1[0]; i < str1[0]+str2[0] && i < 255; i++)
  54.         str1[i+1] = str2[i - str1[0] + 1];
  55.     str1[0] = i;
  56. }
  57. /* end ConcatString */
  58.  
  59.  
  60. /****
  61.  *    CopyString(str1,str2)
  62.  *
  63.  *    Copia la stringa <str2> nella stringa <str1>.
  64.  *
  65.  ****/
  66.  
  67. void CopyString(Str255 str1, Str255 str2)
  68. {
  69.     str1[0] = 0;
  70.     ConcatString(str1,str2);
  71. }
  72. /* end CopyString */
  73.  
  74.  
  75. /****
  76.  *    CToStr255(CString, PString)
  77.  *
  78.  *    Converte la stringa C <CString> nella stringa Pascal <PString>.
  79.  *
  80.  ****/
  81.  
  82. void    CToStr255(char *CString, Str255 PString)
  83. {
  84.     register short    i;
  85.     long            len;
  86.     
  87.     len = strlen(CString);
  88.     if (len > 255L)
  89.         len = 255L;
  90.     PString[0] = (short)len;
  91.     for(i = 0; i < (short)len; i++)
  92.         PString[i+1] = CString[i];
  93. }
  94. /* end CToStr255 */
  95.  
  96.  
  97. /****
  98.  *    Str255ToC(PString, CString)
  99.  *
  100.  *    Converte la stringa Pascal <PString> nella stringa C <CString> (che deve essere lunga
  101.  *    256 bytes.
  102.  *
  103.  ****/
  104.  
  105. void    Str255ToC(Str255 PString, char *CString)
  106. {
  107.     register short    i;
  108.     short            len;
  109.     
  110.     len = PString[0];
  111.     for(i = 0; i < len; i++)
  112.         CString[i] = PString[i+1];
  113.     CString[len] = '\0';
  114. }
  115. /* end Str255ToC */
  116.  
  117.  
  118. /****
  119.  *    DataItaliana(data)
  120.  *
  121.  *    Converte la stringa Pascal <data> dal formato data americano (MM/DD/YYYY) al formato
  122.  *    italiano (DD/MM/YYYY).
  123.  *
  124.  ****/
  125.  
  126. void    DataItaliana(Str255 data){
  127.     short    len, giorno, mese, anno;
  128.     char    *pData;
  129.     
  130.     len = data[0];
  131.     data[len+1] = 0;
  132.     pData = (char *) &data[1];
  133.     sscanf(pData, "%d/%d/%d", &mese, &giorno, &anno);
  134.     sprintf(pData, "%d/%d/%d", giorno, mese, anno);
  135.     data[0] = (short) strlen(pData);
  136. }
  137. /* end DataItaliana */
  138.  
  139.  
  140. /****
  141.  *    DataAmericana(data)
  142.  *
  143.  *    Converte la stringa Pascal <data> dal formato data italiano (DD/MM/YYYY) al formato
  144.  *    americano (MM/DD/YYYY).
  145.  *
  146.  ****/
  147.  
  148. void    DataAmericana(Str255 data)
  149. {
  150.     short    len, giorno, mese, anno;
  151.     char    *pData;
  152.     
  153.     len = data[0];
  154.     data[len+1] = 0;
  155.     pData = (char *) &data[1];
  156.     sscanf(pData, "%d/%d/%d", &giorno, &mese, &anno);
  157.     sprintf(pData, "%d/%d/%d", mese, giorno, anno);
  158.     data[0] = (short) strlen(pData);
  159. }
  160. /* end DataAmericana */
  161.  
  162.  
  163. /****
  164.  *    SostituisciChar(stringa, ch1, ch2)
  165.  *
  166.  *    Sostituisce ogni ricorrenza di <ch1> nella stringa <stringa> con <ch2>.
  167.  *
  168.  ****/
  169.  
  170. void    SostituisciChar(char *stringa, char ch1, char ch2)
  171. {
  172.     register char    *pCh;
  173.     
  174.     while(pCh = strchr(stringa, ch1))
  175.         *pCh = ch2;
  176. }
  177. /* end SostituisciChar */
  178.  
  179.  
  180. /****
  181.  *    EliminaRet(stringa1, stringa2)
  182.  *
  183.  *    Copia <stringa1> in <stringa2>, sostituendo ogni ricorrenza di ".\r" con ", ".
  184.  *
  185.  ****/
  186.  
  187. void    EliminaRet(char *stringa, short lunghezza)
  188. {
  189.     register short    i;
  190.     
  191.     for(i = 0; i < lunghezza-1; i++)
  192.         if(stringa[i] == '.' && (stringa[i+1] == '\r' || stringa[i+1] == '\n'))
  193.         {
  194.             stringa[i] = ',';
  195.             stringa[i+1] = ' ';
  196.         }
  197. }
  198. /* end EliminaRet */
  199.  
  200.  
  201. /****
  202.  *    EliminaRet2(stringa1)
  203.  *
  204.  *    Elimina da stringa1 tutti i caratteri "\r".
  205.  *
  206.  ****/
  207.  
  208. long    EliminaRet2(char *stringa)
  209. {
  210.     long len = 0;
  211.     long leggi = 0;
  212.     long scrivi = 0;
  213.  
  214.     while (stringa[leggi] != '\0')
  215.     {
  216.         if (stringa[leggi] != '\r')
  217.         {
  218.             if (scrivi < leggi)
  219.                 stringa[scrivi] = stringa[leggi];
  220.             scrivi++;
  221.         }
  222.         leggi++;
  223.     }
  224.     len = scrivi;
  225.     stringa[scrivi] = '\0';
  226.     return(len);
  227. }
  228. /* end EliminaRet2 */
  229.  
  230.  
  231. /****
  232.  *    ClipString(theString,clipWidth)
  233.  *
  234.  *    Qualora la lunghezza di <theString> superi <clipWidth>, la riduce ponendo come
  235.  *    ultimo carattere '…'.
  236.  *
  237.  ****/
  238. void        ClipString(Str255 theString, short clipWidth)
  239. {
  240.     short    newWidth, newLenght;
  241.  
  242.     newWidth = StringWidth(theString);
  243.     if(newWidth > clipWidth)
  244.     {
  245.         newLenght = theString[0];
  246.         clipWidth = clipWidth - CharWidth('…');
  247.  
  248.         while(newWidth > clipWidth && newLenght > 0)
  249.         {
  250.             newWidth -= CharWidth(theString[newLenght]);
  251.             newLenght--;
  252.         }
  253.  
  254.         newLenght++;
  255.         theString[newLenght] = '…';
  256.         theString[0] = newLenght;
  257.     }
  258. }
  259. /* end ClipString */
  260.  
  261.  
  262. /****
  263.  *    IsValidString(theString)
  264.  *
  265.  *    Controlla se in <theString> sono presenti caratteri diversi da blank, nel quel caso
  266.  *    torna true.
  267.  *
  268.  ****/
  269.  
  270. Boolean    IsValidString(Str255 theString)
  271. {
  272.     short    i;
  273.     Boolean    ok;
  274.     
  275.     ok = false;
  276.     for(i = 1; i <= theString[0] && !ok; i++)
  277.         if(theString[i] != ' ')
  278.             ok = true;
  279.     return(ok);
  280. }
  281. /* end IsValidString */
  282.  
  283.  
  284. /****
  285.  *    StripStringa(stringa)
  286.  *
  287.  *    Elimina i diacritici in <theString> e la pone minuscola.
  288.  *
  289.  ****/
  290.  
  291. void    StripStringa(char    *stringa)
  292. {
  293.     long    len;
  294.     
  295.     if(stringa == nil)
  296.         return;
  297.     len = strlen(stringa);
  298.     StripText(stringa, len);
  299.     LowerText(stringa, len);
  300. }
  301. /* end StripStringa */
  302.  
  303.  
  304. /****
  305.  *    TrimString(stringa)
  306.  *
  307.  *    Data la stringa <stringa>, toglie i blank iniziali e finali, e sostituisce i blank
  308.  *    multipli all'interno con uno solo.
  309.  *
  310.  ****/
  311.  
  312. void    TrimString(char    *stringa)
  313. {
  314.     short    len, i, j, base;
  315.     char    *pStringa;
  316.     Boolean    trovato;
  317.     
  318.     len = (short)strlen(stringa);
  319.     if(len == 0)
  320.         return;
  321.         
  322.     for(i = len-1; i >= 0; i--)
  323.     {
  324.         if(stringa[i] == ' ')
  325.             stringa[i] = '\0';
  326.         else
  327.             break;
  328.     }
  329.     
  330.     base = 0;
  331.     for(i = 0; stringa[i] != '\0'; i++)
  332.     {
  333.         if(stringa[i] == ' ')
  334.             base = i+1;
  335.         else
  336.             break;
  337.     }
  338.     if(base > 0)
  339.     {
  340.         i = 0;
  341.         for(pStringa = &stringa[base]; *pStringa != '\0'; pStringa++)
  342.             stringa[i++] = *pStringa;
  343.         stringa[i] = '\0';
  344.     }
  345.  
  346.     base = 0;
  347.     do
  348.     {
  349.         trovato = false;
  350.         for(i = base; stringa[i] != '\0'; i++)
  351.         {
  352.             if(stringa[i] == ' ' && stringa[i+1] == ' ')
  353.             {
  354.                 for(j = i+1; stringa[j] != '\0'; j++)
  355.                     stringa[j] = stringa[j+1];
  356.                 stringa[j] = '\0';
  357.                 trovato = true;
  358.                 break;
  359.             }
  360.         }
  361.     } while (trovato);
  362. }
  363. /* end TrimString */
  364.  
  365.  
  366. short    CountCharOccurences(char *theString, char theChar)
  367. {
  368.     register short    i;
  369.     short            count;
  370.     
  371.     if(theString == nil)
  372.         return(0);
  373.     count = 0;
  374.     for(i = 0; theString[i] != '\0'; i++)
  375.         if(theString[i] == theChar)
  376.             count++;
  377.     return(count);
  378. }
  379.